home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / swap.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  11.6 KB  |  423 lines
  1. #ifndef _LINUX_SWAP_H
  2. #define _LINUX_SWAP_H
  3.  
  4. #include <linux/spinlock.h>
  5. #include <linux/linkage.h>
  6. #include <linux/mmzone.h>
  7. #include <linux/list.h>
  8. #include <linux/memcontrol.h>
  9. #include <linux/sched.h>
  10. #include <linux/node.h>
  11.  
  12. #include <asm/atomic.h>
  13. #include <asm/page.h>
  14.  
  15. struct notifier_block;
  16.  
  17. struct bio;
  18.  
  19. #define SWAP_FLAG_PREFER    0x8000    /* set if swap priority specified */
  20. #define SWAP_FLAG_PRIO_MASK    0x7fff
  21. #define SWAP_FLAG_PRIO_SHIFT    0
  22.  
  23. static inline int current_is_kswapd(void)
  24. {
  25.     return current->flags & PF_KSWAPD;
  26. }
  27.  
  28. /*
  29.  * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
  30.  * be swapped to.  The swap type and the offset into that swap type are
  31.  * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
  32.  * for the type means that the maximum number of swapcache pages is 27 bits
  33.  * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
  34.  * the type/offset into the pte as 5/27 as well.
  35.  */
  36. #define MAX_SWAPFILES_SHIFT    5
  37. #ifndef CONFIG_MIGRATION
  38. #define MAX_SWAPFILES        (1 << MAX_SWAPFILES_SHIFT)
  39. #else
  40. /* Use last two entries for page migration swap entries */
  41. #define MAX_SWAPFILES        ((1 << MAX_SWAPFILES_SHIFT)-2)
  42. #define SWP_MIGRATION_READ    MAX_SWAPFILES
  43. #define SWP_MIGRATION_WRITE    (MAX_SWAPFILES + 1)
  44. #endif
  45.  
  46. /*
  47.  * Magic header for a swap area. The first part of the union is
  48.  * what the swap magic looks like for the old (limited to 128MB)
  49.  * swap area format, the second part of the union adds - in the
  50.  * old reserved area - some extra information. Note that the first
  51.  * kilobyte is reserved for boot loader or disk label stuff...
  52.  *
  53.  * Having the magic at the end of the PAGE_SIZE makes detecting swap
  54.  * areas somewhat tricky on machines that support multiple page sizes.
  55.  * For 2.5 we'll probably want to move the magic to just beyond the
  56.  * bootbits...
  57.  */
  58. union swap_header {
  59.     struct {
  60.         char reserved[PAGE_SIZE - 10];
  61.         char magic[10];            /* SWAP-SPACE or SWAPSPACE2 */
  62.     } magic;
  63.     struct {
  64.         char        bootbits[1024];    /* Space for disklabel etc. */
  65.         __u32        version;
  66.         __u32        last_page;
  67.         __u32        nr_badpages;
  68.         unsigned char    sws_uuid[16];
  69.         unsigned char    sws_volume[16];
  70.         __u32        padding[117];
  71.         __u32        badpages[1];
  72.     } info;
  73. };
  74.  
  75.  /* A swap entry has to fit into a "unsigned long", as
  76.   * the entry is hidden in the "index" field of the
  77.   * swapper address space.
  78.   */
  79. typedef struct {
  80.     unsigned long val;
  81. } swp_entry_t;
  82.  
  83. /*
  84.  * current->reclaim_state points to one of these when a task is running
  85.  * memory reclaim
  86.  */
  87. struct reclaim_state {
  88.     unsigned long reclaimed_slab;
  89. };
  90.  
  91. #ifdef __KERNEL__
  92.  
  93. struct address_space;
  94. struct sysinfo;
  95. struct writeback_control;
  96. struct zone;
  97.  
  98. /*
  99.  * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
  100.  * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
  101.  * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
  102.  * from setup, they're handled identically.
  103.  *
  104.  * We always assume that blocks are of size PAGE_SIZE.
  105.  */
  106. struct swap_extent {
  107.     struct list_head list;
  108.     pgoff_t start_page;
  109.     pgoff_t nr_pages;
  110.     sector_t start_block;
  111. };
  112.  
  113. /*
  114.  * Max bad pages in the new format..
  115.  */
  116. #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
  117. #define MAX_SWAP_BADPAGES \
  118.     ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
  119.  
  120. enum {
  121.     SWP_USED    = (1 << 0),    /* is slot in swap_info[] used? */
  122.     SWP_WRITEOK    = (1 << 1),    /* ok to write to this swap?    */
  123.     SWP_ACTIVE    = (SWP_USED | SWP_WRITEOK),
  124.                     /* add others here before... */
  125.     SWP_SCANNING    = (1 << 8),    /* refcount in scan_swap_map */
  126. };
  127.  
  128. #define SWAP_CLUSTER_MAX 32
  129.  
  130. #define SWAP_MAP_MAX    0x7fff
  131. #define SWAP_MAP_BAD    0x8000
  132.  
  133. /*
  134.  * The in-memory structure used to track swap areas.
  135.  */
  136. struct swap_info_struct {
  137.     unsigned int flags;
  138.     int prio;            /* swap priority */
  139.     struct file *swap_file;
  140.     struct block_device *bdev;
  141.     struct list_head extent_list;
  142.     struct swap_extent *curr_swap_extent;
  143.     unsigned old_block_size;
  144.     unsigned short * swap_map;
  145.     unsigned int lowest_bit;
  146.     unsigned int highest_bit;
  147.     unsigned int cluster_next;
  148.     unsigned int cluster_nr;
  149.     unsigned int pages;
  150.     unsigned int max;
  151.     unsigned int inuse_pages;
  152.     int next;            /* next entry on swap list */
  153.     void (*notify_swap_entry_free_fn) (unsigned long);
  154. };
  155.  
  156. struct swap_list_t {
  157.     int head;    /* head of priority-ordered swapfile list */
  158.     int next;    /* swapfile to be used next */
  159. };
  160.  
  161. /* Swap 50% full? Release swapcache more aggressively.. */
  162. #define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
  163.  
  164. /* linux/mm/page_alloc.c */
  165. extern unsigned long totalram_pages;
  166. extern unsigned long totalreserve_pages;
  167. extern long nr_swap_pages;
  168. extern unsigned int nr_free_buffer_pages(void);
  169. extern unsigned int nr_free_pagecache_pages(void);
  170.  
  171. /* Definition of global_page_state not available yet */
  172. #define nr_free_pages() global_page_state(NR_FREE_PAGES)
  173.  
  174.  
  175. /* linux/mm/swap.c */
  176. extern void __lru_cache_add(struct page *, enum lru_list lru);
  177. extern void lru_cache_add_lru(struct page *, enum lru_list lru);
  178. extern void lru_cache_add_active_or_unevictable(struct page *,
  179.                     struct vm_area_struct *);
  180. extern void activate_page(struct page *);
  181. extern void mark_page_accessed(struct page *);
  182. extern void lru_add_drain(void);
  183. extern int lru_add_drain_all(void);
  184. extern void rotate_reclaimable_page(struct page *page);
  185. extern void swap_setup(void);
  186.  
  187. extern void add_page_to_unevictable_list(struct page *page);
  188.  
  189. /**
  190.  * lru_cache_add: add a page to the page lists
  191.  * @page: the page to add
  192.  */
  193. static inline void lru_cache_add_anon(struct page *page)
  194. {
  195.     __lru_cache_add(page, LRU_INACTIVE_ANON);
  196. }
  197.  
  198. static inline void lru_cache_add_active_anon(struct page *page)
  199. {
  200.     __lru_cache_add(page, LRU_ACTIVE_ANON);
  201. }
  202.  
  203. static inline void lru_cache_add_file(struct page *page)
  204. {
  205.     __lru_cache_add(page, LRU_INACTIVE_FILE);
  206. }
  207.  
  208. static inline void lru_cache_add_active_file(struct page *page)
  209. {
  210.     __lru_cache_add(page, LRU_ACTIVE_FILE);
  211. }
  212.  
  213. /* linux/mm/vmscan.c */
  214. extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
  215.                     gfp_t gfp_mask);
  216. extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
  217.                             gfp_t gfp_mask);
  218. extern int __isolate_lru_page(struct page *page, int mode, int file);
  219. extern unsigned long shrink_all_memory(unsigned long nr_pages);
  220. extern int vm_swappiness;
  221. extern int remove_mapping(struct address_space *mapping, struct page *page);
  222. extern long vm_total_pages;
  223.  
  224. #ifdef CONFIG_NUMA
  225. extern int zone_reclaim_mode;
  226. extern int sysctl_min_unmapped_ratio;
  227. extern int sysctl_min_slab_ratio;
  228. extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
  229. #else
  230. #define zone_reclaim_mode 0
  231. static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
  232. {
  233.     return 0;
  234. }
  235. #endif
  236.  
  237. #ifdef CONFIG_UNEVICTABLE_LRU
  238. extern int page_evictable(struct page *page, struct vm_area_struct *vma);
  239. extern void scan_mapping_unevictable_pages(struct address_space *);
  240.  
  241. extern unsigned long scan_unevictable_pages;
  242. extern int scan_unevictable_handler(struct ctl_table *, int, struct file *,
  243.                     void __user *, size_t *, loff_t *);
  244. extern int scan_unevictable_register_node(struct node *node);
  245. extern void scan_unevictable_unregister_node(struct node *node);
  246. #else
  247. static inline int page_evictable(struct page *page,
  248.                         struct vm_area_struct *vma)
  249. {
  250.     return 1;
  251. }
  252.  
  253. static inline void scan_mapping_unevictable_pages(struct address_space *mapping)
  254. {
  255. }
  256.  
  257. static inline int scan_unevictable_register_node(struct node *node)
  258. {
  259.     return 0;
  260. }
  261.  
  262. static inline void scan_unevictable_unregister_node(struct node *node) { }
  263. #endif
  264.  
  265. extern int kswapd_run(int nid);
  266.  
  267. #ifdef CONFIG_MMU
  268. /* linux/mm/shmem.c */
  269. extern int shmem_unuse(swp_entry_t entry, struct page *page);
  270. #endif /* CONFIG_MMU */
  271.  
  272. extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
  273.  
  274. #ifdef CONFIG_SWAP
  275. /* linux/mm/page_io.c */
  276. extern int swap_readpage(struct file *, struct page *);
  277. extern int swap_writepage(struct page *page, struct writeback_control *wbc);
  278. extern void end_swap_bio_read(struct bio *bio, int err);
  279.  
  280. /* linux/mm/swap_state.c */
  281. extern struct address_space swapper_space;
  282. #define total_swapcache_pages  swapper_space.nrpages
  283. extern void show_swap_cache_info(void);
  284. extern int add_to_swap(struct page *, gfp_t);
  285. extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
  286. extern void __delete_from_swap_cache(struct page *);
  287. extern void delete_from_swap_cache(struct page *);
  288. extern void free_page_and_swap_cache(struct page *);
  289. extern void free_pages_and_swap_cache(struct page **, int);
  290. extern struct page *lookup_swap_cache(swp_entry_t);
  291. extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
  292.             struct vm_area_struct *vma, unsigned long addr);
  293. extern struct page *swapin_readahead(swp_entry_t, gfp_t,
  294.             struct vm_area_struct *vma, unsigned long addr);
  295.  
  296. /* linux/mm/swapfile.c */
  297. extern long total_swap_pages;
  298. extern void si_swapinfo(struct sysinfo *);
  299. extern swp_entry_t get_swap_page(void);
  300. extern swp_entry_t get_swap_page_of_type(int);
  301. extern int swap_duplicate(swp_entry_t);
  302. extern int valid_swaphandles(swp_entry_t, unsigned long *);
  303. extern void swap_free(swp_entry_t);
  304. extern void free_swap_and_cache(swp_entry_t);
  305. extern int swap_type_of(dev_t, sector_t, struct block_device **);
  306. extern unsigned int count_swap_pages(int, int);
  307. extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
  308. extern sector_t swapdev_block(int, pgoff_t);
  309. extern struct swap_info_struct *get_swap_info_struct(unsigned);
  310. extern int can_share_swap_page(struct page *);
  311. extern int remove_exclusive_swap_page(struct page *);
  312. extern int remove_exclusive_swap_page_ref(struct page *);
  313. extern void set_notify_swap_entry_free(unsigned, void (*) (unsigned long));
  314. struct backing_dev_info;
  315.  
  316. /* linux/mm/thrash.c */
  317. extern struct mm_struct * swap_token_mm;
  318. extern void grab_swap_token(void);
  319. extern void __put_swap_token(struct mm_struct *);
  320.  
  321. static inline int has_swap_token(struct mm_struct *mm)
  322. {
  323.     return (mm == swap_token_mm);
  324. }
  325.  
  326. static inline void put_swap_token(struct mm_struct *mm)
  327. {
  328.     if (has_swap_token(mm))
  329.         __put_swap_token(mm);
  330. }
  331.  
  332. static inline void disable_swap_token(void)
  333. {
  334.     put_swap_token(swap_token_mm);
  335. }
  336.  
  337. #else /* CONFIG_SWAP */
  338.  
  339. #define total_swap_pages            0
  340. #define total_swapcache_pages            0UL
  341.  
  342. #define si_swapinfo(val) \
  343.     do { (val)->freeswap = (val)->totalswap = 0; } while (0)
  344. /* only sparc can not include linux/pagemap.h in this file
  345.  * so leave page_cache_release and release_pages undeclared... */
  346. #define free_page_and_swap_cache(page) \
  347.     page_cache_release(page)
  348. #define free_pages_and_swap_cache(pages, nr) \
  349.     release_pages((pages), (nr), 0);
  350.  
  351. static inline void show_swap_cache_info(void)
  352. {
  353. }
  354.  
  355. static inline void free_swap_and_cache(swp_entry_t swp)
  356. {
  357. }
  358.  
  359. static inline int swap_duplicate(swp_entry_t swp)
  360. {
  361.     return 0;
  362. }
  363.  
  364. static inline void swap_free(swp_entry_t swp)
  365. {
  366. }
  367.  
  368. static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
  369.             struct vm_area_struct *vma, unsigned long addr)
  370. {
  371.     return NULL;
  372. }
  373.  
  374. static inline struct page *lookup_swap_cache(swp_entry_t swp)
  375. {
  376.     return NULL;
  377. }
  378.  
  379. #define can_share_swap_page(p)            (page_mapcount(p) == 1)
  380.  
  381. static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
  382.                             gfp_t gfp_mask)
  383. {
  384.     return -1;
  385. }
  386.  
  387. static inline void __delete_from_swap_cache(struct page *page)
  388. {
  389. }
  390.  
  391. static inline void delete_from_swap_cache(struct page *page)
  392. {
  393. }
  394.  
  395. #define swap_token_default_timeout        0
  396.  
  397. static inline int remove_exclusive_swap_page(struct page *p)
  398. {
  399.     return 0;
  400. }
  401.  
  402. static inline int remove_exclusive_swap_page_ref(struct page *page)
  403. {
  404.     return 0;
  405. }
  406.  
  407. static inline swp_entry_t get_swap_page(void)
  408. {
  409.     swp_entry_t entry;
  410.     entry.val = 0;
  411.     return entry;
  412. }
  413.  
  414. /* linux/mm/thrash.c */
  415. #define put_swap_token(x) do { } while(0)
  416. #define grab_swap_token()  do { } while(0)
  417. #define has_swap_token(x) 0
  418. #define disable_swap_token() do { } while(0)
  419.  
  420. #endif /* CONFIG_SWAP */
  421. #endif /* __KERNEL__*/
  422. #endif /* _LINUX_SWAP_H */
  423.